.TH std::experimental::propagate_const 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::experimental::propagate_const \- std::experimental::propagate_const

.SH Synopsis
   Defined in header <experimental/propagate_const>
   template< class T >                               (library fundamentals TS v2)
   class propagate_const;

   std::experimental::propagate_const is a const-propagating wrapper for pointers and
   pointer-like objects. It treats the wrapped pointer as a pointer to const when
   accessed through a const access path, hence the name.

   The class satisfies the requirements of MoveConstructible and MoveAssignable if the
   underlying pointer-like type satisfies the corresponding requirement, but
   propagate_const is neither CopyConstructible nor CopyAssignable.

.SH Type requirements
   -
   T must be cv-unqualified pointer-to-object type or a cv-unqualified pointer-like
   class type, as specified below.

.SH Member types

   Member type  Definition
   element_type std::remove_reference_t<decltype(*std::declval<T&>())>, the type of the
                object pointed to by T

.SH Member functions

   constructor                  constructs a new propagate_const
                                \fI(public member function)\fP
   destructor                   destructs a propagate_const, destroying the contained
   (implicitly declared)        pointer
                                \fI(public member function)\fP
   operator=                    assigns the propagate_const object
                                \fI(public member function)\fP
   swap                         swaps the wrapped pointer
                                \fI(public member function)\fP
.SH Observers
                                returns a pointer to the object pointed to by the
   get                          wrapped pointer
                                \fI(public member function)\fP
   operator bool                checks if the wrapped pointer is null
                                \fI(public member function)\fP
   operator*                    dereferences the wrapped pointer
   operator->                   \fI(public member function)\fP
   operator element_type*       implicit conversion function to pointer
   operator const element_type* \fI(public member function)\fP

.SH Non-member functions

   operator==                                                  compares to another
   operator!=                                                  propagate_const, another
   operator<                                                   pointer, or with nullptr
   operator<=                                                  \fI(function template)\fP
   operator>
   operator>=
                                                               specializes the swap
   std::experimental::swap(std::experimental::propagate_const) algorithm
                                                               \fI(function template)\fP

                                                               retrieves a reference to
                                                               the wrapped pointer-like
   get_underlying                                              object
                                                               \fI(function template)\fP


.SH Helper classes

                                                          hash support for
   std::hash<std::experimental::propagate_const>          propagate_const
                                                          (class template
                                                          specialization)
   std::equal_to<std::experimental::propagate_const>      specializations of the
   std::not_equal_to<std::experimental::propagate_const>  standard comparison function
   std::less<std::experimental::propagate_const>          objects for propagate_const
   std::greater<std::experimental::propagate_const>       (class template
   std::less_equal<std::experimental::propagate_const>    specialization)
   std::greater_equal<std::experimental::propagate_const>

.SH Example


// Run this code

 #include <experimental/propagate_const>
 #include <iostream>
 #include <memory>

 struct X
 {
     void g() const { std::cout << "X::g (const)\\n"; }
     void g() { std::cout << "X::g (non-const)\\n"; }
 };

 struct Y
 {
     Y() : m_propConstX(std::make_unique<X>()), m_autoPtrX(std::make_unique<X>()) {}

     void f() const
     {
         std::cout << "Y::f (const)\\n";
         m_propConstX->g();
         m_autoPtrX->g();
     }

     void f()
     {
         std::cout << "Y::f (non-const)\\n";
         m_propConstX->g();
         m_autoPtrX->g();
     }

     std::experimental::propagate_const<std::unique_ptr<X>> m_propConstX;
     std::unique_ptr<X> m_autoPtrX;
 };

 int main()
 {
     Y y;
     y.f();

     const Y cy;
     cy.f();
 }

.SH Output:

 Y::f (non-const)
 X::g (non-const)
 X::g (non-const)
 Y::f (const)
 X::g (const)
 X::g (non-const)

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

      DR    Applied to              Behavior as published              Correct behavior
   LWG 3136 LFTSv2     meaningless T like int* const, void*, or const  disallowed
                       PtrLike were allowed
